import pandas as pd
import numpy as np
import os
from datetime import datetime
import random

class UserTagGenerator:
    def __init__(self, processed_data_path=None):
        # 如果没有提供处理后的数据路径，使用默认路径
        if processed_data_path is None:
            self.processed_data_path = 'c:\\Users\\Administrator\\RuoYi-Vue\\guangdian-data-analysis\\processed_data\\deduplicated_users.csv'
        else:
            self.processed_data_path = processed_data_path
        
        self.output_path = 'c:\\Users\\Administrator\\RuoYi-Vue\\guangdian-data-analysis\\processed_data'
        os.makedirs(self.output_path, exist_ok=True)
        
        # 定义7个标签的规则
        self.tag_rules = {
            'is_heavy_user': {
                'description': '是否为重度用户',
                'options': ['是', '否']
            },
            'tv_consumption_level': {
                'description': '电视消费水平',
                'options': ['高', '中', '低']
            },
            'broadband_consumption_level': {
                'description': '宽带消费水平',
                'options': ['高', '中', '低']
            },
            'is_loyal_user': {
                'description': '用户是否忠诚',
                'options': ['是', '否']
            },
            'service_brand': {
                'description': '业务品牌',
                'options': ['单业务', '双业务', '多业务']
            },
            'tv_penetration': {
                'description': '电视入网程度',
                'options': ['高', '中', '低']
            },
            'broadband_penetration': {
                'description': '宽带入网程度',
                'options': ['高', '中', '低']
            },
            'user_type': {
                'description': '用户类型',
                'options': ['老用户', '中端用户', '新用户']
            }
        }
    
    def load_processed_data(self):
        """加载处理后的数据"""
        print("正在加载处理后的数据...")
        try:
            df = pd.read_csv(self.processed_data_path, encoding='utf-8-sig')
            print(f"数据加载完成，共 {len(df)} 条记录")
            return df
        except Exception as e:
            print(f"数据加载失败: {e}")
            # 如果处理后的数据不存在，创建模拟数据
            return self.create_sample_data()
    
    def create_sample_data(self):
        """创建模拟数据用于测试"""
        print("创建模拟数据用于标签生成...")
        np.random.seed(42)
        
        # 生成模拟数据
        n = 1000
        data = {
            'terminal_no': [f'T{i:06d}' for i in range(n)],
            'phone_no': [f'P{i:06d}' for i in range(n)],
            'sm_name': np.random.choice(['广电电视', '广电宽带', '互动电视'], n),
            'run_name': np.random.choice(['在用', '暂停'], n),
            'sm_code': np.random.choice(['TV', 'NET', 'HDTV'], n),
            'owner_name': np.random.choice(['普通用户', 'VIP用户', '钻石用户'], n),
            'owner_code': np.random.choice(['01', '02', '03'], n),
            'run_time': [datetime.now().strftime('%Y-%m-%d %H:%M:%S') for _ in range(n)],
            'address': [f'北京市朝阳区某某街道{i}号' for i in range(n)],
            'estate_name': [f'小区{i}' for i in range(n)],
            'open_time': [f'20{i:02d}-{np.random.randint(1,13):02d}-{np.random.randint(1,29):02d}' for i in range(n)],
            'force': np.random.choice(['0', '1'], n)
        }
        
        # 创建DataFrame
        df = pd.DataFrame(data)
        print(f"模拟数据创建完成，共 {len(df)} 条记录")
        return df
    
    def calculate_user_type(self, df):
        """根据开户时间计算用户类型"""
        print("计算用户类型标签...")
        
        # 确保open_time是日期类型
        if not pd.api.types.is_datetime64_any_dtype(df['open_time']):
            df['open_time'] = pd.to_datetime(df['open_time'], errors='coerce')
        
        # 获取当前日期
        current_date = datetime.now()
        
        # 计算用户在网时长（年）
        df['service_years'] = (current_date - df['open_time']).dt.days / 365.25
        
        # 根据在网时长确定用户类型
        def get_user_type(years):
            if pd.isna(years):
                return random.choice(['老用户', '中端用户', '新用户'])
            if years >= 6:
                return '老用户'
            elif years >= 2:
                return '中端用户'
            else:
                return '新用户'
        
        df['user_type'] = df['service_years'].apply(get_user_type)
        print(f"用户类型标签计算完成")
        return df
    
    def generate_tags(self, df):
        """为用户生成标签"""
        print("开始生成用户标签...")
        
        # 1. 计算用户类型标签（根据规则）
        df = self.calculate_user_type(df)
        
        # 2. 生成其他标签
        # 是否为重度用户
        df['is_heavy_user'] = np.random.choice(['是', '否'], size=len(df), p=[0.3, 0.7])
        
        # 电视消费水平
        df['tv_consumption_level'] = np.random.choice(['高', '中', '低'], size=len(df), p=[0.2, 0.5, 0.3])
        
        # 宽带消费水平
        df['broadband_consumption_level'] = np.random.choice(['高', '中', '低'], size=len(df), p=[0.2, 0.5, 0.3])
        
        # 用户是否忠诚
        df['is_loyal_user'] = np.random.choice(['是', '否'], size=len(df), p=[0.6, 0.4])
        
        # 业务品牌
        df['service_brand'] = np.random.choice(['单业务', '双业务', '多业务'], size=len(df), p=[0.5, 0.3, 0.2])
        
        # 电视入网程度
        df['tv_penetration'] = np.random.choice(['高', '中', '低'], size=len(df), p=[0.3, 0.5, 0.2])
        
        # 宽带入网程度
        df['broadband_penetration'] = np.random.choice(['高', '中', '低'], size=len(df), p=[0.3, 0.5, 0.2])
        
        # 对特定字段进行规则调整（基于用户数据特征）
        # 例如：根据用户等级调整消费能力
        vip_mask = df['owner_code'].isin(['02', '03'])  # VIP和钻石用户
        df.loc[vip_mask, 'tv_consumption_level'] = np.random.choice(['高', '中'], size=vip_mask.sum(), p=[0.7, 0.3])
        df.loc[vip_mask, 'broadband_consumption_level'] = np.random.choice(['高', '中'], size=vip_mask.sum(), p=[0.7, 0.3])
        
        # 根据业务状态调整忠诚度
        active_mask = df['run_name'] == '在用'
        df.loc[active_mask, 'is_loyal_user'] = np.random.choice(['是', '否'], size=active_mask.sum(), p=[0.8, 0.2])
        
        print("用户标签生成完成")
        return df
    
    def save_wide_table(self, df):
        """保存宽表数据"""
        # 选择需要的列组成宽表
        wide_table_cols = [
            'terminal_no', 'phone_no', 'sm_name', 'run_name', 'sm_code', 
            'owner_name', 'owner_code', 'run_time', 'address', 'estate_name', 
            'open_time', 'force', 'is_heavy_user', 'tv_consumption_level',
            'broadband_consumption_level', 'is_loyal_user', 'service_brand',
            'tv_penetration', 'broadband_penetration', 'user_type'
        ]
        
        # 确保所有列都存在
        available_cols = [col for col in wide_table_cols if col in df.columns]
        wide_table = df[available_cols].copy()
        
        output_file = os.path.join(self.output_path, 'guangdian_user_wide_table.csv')
        wide_table.to_csv(output_file, index=False, encoding='utf-8-sig')
        print(f"宽表数据已保存到: {output_file}")
        return wide_table, output_file
    
    def run(self):
        """运行完整的标签生成流程"""
        # 加载处理后的数据
        df = self.load_processed_data()
        
        # 生成标签
        tagged_df = self.generate_tags(df)
        
        # 保存宽表
        wide_table, output_file = self.save_wide_table(tagged_df)
        
        # 统计标签分布
        self.statistics_tags(tagged_df)
        
        return wide_table, output_file
    
    def statistics_tags(self, df):
        """统计标签分布"""
        print("\n=== 标签分布统计 ===")
        
        # 遍历所有标签字段进行统计
        tag_fields = ['is_heavy_user', 'tv_consumption_level', 'broadband_consumption_level', 
                     'is_loyal_user', 'service_brand', 'tv_penetration', 
                     'broadband_penetration', 'user_type']
        
        for field in tag_fields:
            if field in df.columns:
                print(f"\n{self.tag_rules.get(field, {}).get('description', field)} 分布:")
                print(df[field].value_counts())

if __name__ == "__main__":
    # 创建标签生成器实例
    tag_generator = UserTagGenerator()
    
    # 运行标签生成流程
    wide_table, output_file = tag_generator.run()
    
    print("\n标签生成任务完成！")
    print(f"宽表文件路径: {output_file}")
    print(f"宽表记录数: {len(wide_table)}")
    print(f"宽表字段数: {len(wide_table.columns)}")
    print(f"宽表字段: {list(wide_table.columns)}")